Õpi Pythoni abil nullist turvalist krüptovaluuta rahakotti ehitama. See põhjalik juhend hõlmab peamisi kontseptsioone, krüptograafiat, teeke ja praktilisi koodinäiteid ülemaailmsele publikule.
Krüptovaluuta rahakoti ehitamine Pythoniga: põhjalik juhend
Digitaalse rahanduse kiiresti arenevas maailmas on krüptovaluutad esile kerkinud kui transformatiivne jõud. Selle revolutsiooni keskmes on rahakoti kontseptsioon – teie isiklik värav plokiahela võrkudega suhtlemiseks. Kuigi on palju kaubanduslikke rahakotte, on iga arendaja või tehnoloogia entusiasti jaoks hindamatu oskus mõista, kuidas need kulisside taga töötavad. See juhend demüstifitseerib protsessi, juhendades teid funktsionaalse krüptovaluuta rahakoti loomisel Pythoni abil.
Me käsitleme peamisi krüptograafilisi põhimõtteid, olulisi Pythoni teeke ja samm-sammult rakendamist võtmete genereerimiseks, aadresside loomiseks nii Bitcoini kui ka Ethereumi jaoks ja tehingute allkirjastamiseks. Selle artikli lõpuks on teil kindel arusaam rahakoti mehaanikast ja töötav käsurea rahakott.
Hoiatus: Selles juhendis esitatud kood ja kontseptsioonid on mõeldud ainult hariduslikel eesmärkidel. Tootmistaseme rahakoti ehitamine nõuab rangeid turvaauditeid, ulatuslikke teste ja täiustatud turvameetmeid. Ärge kasutage siin loodud rahakotti reaalse raha hoidmiseks.
Krüptovaluuta rahakoti põhikontseptsioonide mõistmine
Enne ainsagi koodirea kirjutamist on ülioluline mõista, mis krüptovaluuta rahakott tegelikult on. Erinevalt oma nimest ei "salvesta" rahakott teie münte. Teie krüptovaluuta eksisteerib kirjenditena hajutatud pearaamatus – plokiahelas. Rahakott on tarkvara, mis haldab krüptograafilisi võtmeid, mis annavad teile omandiõiguse ja kontrolli oma varade üle selles pearaamatus.
Iga mitte-hoiura rahakoti peamised komponendid on:
1. Privaatsed võtmed: teie digitaalne saladus
Privaatvõti on teie rahakoti kõige olulisem teave. See on väga suur, juhuslikult genereeritud number, mida hoitakse saladuses ja mis on teada ainult teile. Selle eesmärk on luua digitaalallkiri, mis on vaieldamatu tõend selle kohta, et olete tehingu autoriseerinud. Kui kaotate oma privaatse võtme, kaotate igaveseks juurdepääsu oma rahale. Kui keegi teine saab sellele juurdepääsu, on tal teie raha üle täielik kontroll.
- Analoogia: Mõelge privaatsele võtmele kui oma digitaalse seifi peavõtmele. See võib avada seifi ja autoriseerida selle sisu liikumist.
2. Avalikud võtmed: teie jagatav identifikaator
Avalik võti on matemaatiliselt tuletatud teie privaatsest võtmest, kasutades ühesuunalist krüptograafilist funktsiooni, mida tuntakse kui Elliptic Curve Cryptography (ECC). Kuigi avalikku võtit on võimalik genereerida privaatsest võtmest, on vastupidise tegemine arvutuslikult võimatu. See ühesuunaline suhe on krüptovaluuta turvalisuse aluseks.
- Analoogia: Avalik võti on nagu teie pangakonto number. Saate seda teistega jagada, et nad saaksid teile raha saata, kuid see ei anna neile võimalust raha välja võtta.
3. Aadressid: teie avalik sihtkoht
Rahakoti aadress on teie avaliku võtme lühem ja kasutajasõbralikum esitus. See genereeritakse, rakendades avalikule võtmele täiendavaid räsialgoritme (nagu SHA-256 ja RIPEMD-160) ja sisaldab sageli kontrollsummat, et vältida trükivigu raha saatmisel. See on märgistring, mida jagate teistega krüptovaluuta vastuvõtmiseks.
- Analoogia: Kui avalik võti on teie kontonumber, siis aadress on nagu konkreetne, vormindatud arvenumber, mis sisaldab veakontrolli funktsioone.
4. Krüptograafiline link: ühesuunaline tänav
Nende komponentide vaheline suhe on range, ĂĽhesuunaline hierarhia:
Privaatne võti → Avalik võti → Aadress
See disain tagab, et saate oma aadressi turvaliselt jagada, ilma et avalikustaksite oma avalikku võtit otse (mõnel juhul) ja kindlasti ilma kunagi oma privaatset võtit avaldamata.
5. Digitaalallkirjad: omandiõiguse tõend
Kui soovite saata krüptovaluutat, loote tehingusõnumi (nt "Saada 0,5 BTC aadressilt A aadressile B"). Teie rahakoti tarkvara kasutab seejärel teie privaatset võtit, et luua sellele konkreetsele tehingule unikaalne digitaalallkiri. See allkiri edastatakse võrgule koos tehinguga. Kaevurid ja võrgusõlmed saavad teie avaliku võtme abil kontrollida, kas allkiri on kehtiv, kinnitades, et tehing on autoriseeritud raha seadusliku omaniku poolt, ilma et nad kunagi teie privaatset võtit näeksid.
Pythoni arenduskeskkonna seadistamine
Meie rahakoti ehitamiseks vajame mõnda spetsiaalset Pythoni teeki, mis käsitlevad keerulist krüptograafiat. Veenduge, et teil on installitud Python 3.6 või uuem. Vajalikud paketid saate installida pip abil:
pip install ecdsa pysha3 base58
Vaatame lähemalt, mida iga teek teeb:
- ecdsa: See on ülioluline teek Elliptic Curve Digital Signature Algorithm (ECDSA) rakendamiseks. Me kasutame seda privaatsete ja avalike võtmete genereerimiseks, mis põhinevad
SECP256k1kõveral, mis on Bitcoini, Ethereumi ja paljude teiste krüptovaluutade standard. See haldab ka digitaalallkirjade loomist ja kontrollimist. - pysha3: Kuigi Pythoni sisseehitatud
hashlibtoetab paljusid räsialgoritme, ei sisalda see Keccak-256, mis on vajalik Ethereumi aadresside genereerimiseks. See teek pakub seda funktsionaalsust. - base58: See teek rakendab Base58Check kodeeringut, mis on vorming, mida kasutatakse inimesele loetavate Bitcoini aadresside loomiseks. See sisaldab kontrollsummat, et aidata vältida trükivigadest tulenevaid vigu.
- hashlib: Seda sisseehitatud Pythoni teeki kasutatakse SHA-256 ja RIPEMD-160 räsimiseks, mis on olulised sammud Bitcoini aadressi loomisel.
Samm-sammult rakendamine: rahakoti loogika ehitamine
Nüüd sukeldume koodi. Me ehitame oma rahakoti põhifunktsioonid tükk-tükilt, selgitades iga sammu teel.
1. samm: privaatse võtme genereerimine
Privaatvõti on sisuliselt 256-bitine (32-baidine) number. Kõige olulisem nõue on, et see tuleb genereerida tõelise juhuslikkusega. Nõrga juhuslike arvude generaatori kasutamine võib viia ennustatavate võtmeteni, mida ründaja võib ära arvata.
Pythoni sisseehitatud secrets moodul on mõeldud krüptograafiliselt turvaliste juhuslike arvude genereerimiseks, muutes selle meie vajaduste jaoks ideaalseks.
Siin pakub `os.urandom(32)` 32 krüptograafiliselt turvalist juhuslikku baiti, mis on täpselt see, mida me vajame 256-bitise privaatvõtme jaoks.
2. samm: avaliku võtme tuletamine
Järgmisena tuletame avaliku võtme privaatsest võtmest, kasutades `SECP256k1` elliptilist kõverat. `ecdsa` teek muudab selle protsessi lihtsaks.
```python def private_key_to_public_key(private_key_bytes): """Teisenda privaatne võti vastavaks avalikuks võtmeks.""" # SECP256k1 on kõver, mida kasutavad Bitcoin ja Ethereum sk = ecdsa.SigningKey.from_string(private_key_bytes, curve=ecdsa.SECP256k1) # Hangi avalik võti tihendamata vormingus (algab 0x04-ga) vk = sk.verifying_key public_key_bytes = vk.to_string("uncompressed") return public_key_bytes ````ecdsa.SigningKey` objekt tähistab meie privaatset võtit. Seejärel saame vastava `verifying_key` (avaliku võtme) ja ekspordime selle tihendamata vormingus. Tihendamata avalik võti on 65 baiti pikk: eesliide `0x04`, millele järgneb elliptilise kõvera punkti 32-baidine X-koordinaat ja 32-baidine Y-koordinaat.
3. samm: Bitcoini aadressi loomine
Bitcoini aadressi genereerimine avalikust võtmest on mitmeastmeline protsess, mis on mõeldud turvalisuse ja veakontrolli jaoks. Siin on standardne P2PKH (Pay-to-Public-Key-Hash) aadressi genereerimise voog:
- SHA-256 räsimine: Räsi avalik võti, kasutades SHA-256.
- RIPEMD-160 räsimine: Räsi eelmise sammu tulemus, kasutades RIPEMD-160.
- Lisa versioonibait: Lisa RIPEMD-160 räsile versioonibaidi eesliide. Bitcoini peavõrgu jaoks on see `0x00`.
- Kontrollsumma arvutamine: Tee laiendatud räsi peal SHA-256 räsimine kaks korda ja võta lõpliku räsi esimesed 4 baiti. See on kontrollsumma.
- Lisa kontrollsumma: Lisa 4-baidine kontrollsumma versiooniga eesliitega räsi lõppu.
- Base58Check kodeering: Kodeeri kogu baidistring, kasutades Base58Check, et saada lõplik, inimesele loetav aadress.
Rakendame seda Pythonis:
```python def public_key_to_btc_address(public_key_bytes): """Teisenda avalik võti Bitcoini P2PKH aadressiks.""" # 1. ja 2. samm: SHA-256 ja seejärel RIPEMD-160 sha256_hash = hashlib.sha256(public_key_bytes).digest() ripemd160_hash = hashlib.new('ripemd160') ripemd160_hash.update(sha256_hash) hashed_public_key = ripemd160_hash.digest() # 3. samm: lisa versioonibait (0x00 peavõrgu jaoks) version_byte = b'\x00' versioned_hash = version_byte + hashed_public_key # 4. ja 5. samm: loo kontrollsumma ja lisa # Kahekordne SHA-256 räsi checksum_hash_1 = hashlib.sha256(versioned_hash).digest() checksum_hash_2 = hashlib.sha256(checksum_hash_1).digest() checksum = checksum_hash_2[:4] binary_address = versioned_hash + checksum # 6. samm: Base58Check kodeeri btc_address = base58.b58encode(binary_address).decode('utf-8') return btc_address ```4. samm: Ethereumi aadressi loomine
Ethereumi aadressi genereerimine on Bitcoini omaga võrreldes lihtsam. See hõlmab avaliku võtme Keccak-256 räsi võtmist ja tulemuse viimase 20 baidi kasutamist.
- Keccak-256 räsimine: Võta avaliku võtme Keccak-256 räsi. Pange tähele, et me peame kasutama avalikku võtit *ilma* `0x04` eesliiteta.
- Võta viimased 20 baiti: Ethereumi aadress on selle räsi viimased 20 baiti (40 kuueteistkümnendsümbolit).
- Vormindus: Aadressile on standardne lisada eesliide `0x`.
Rakendame seda, kasutades `pysha3`:
```python def public_key_to_eth_address(public_key_bytes): """Teisenda avalik võti Ethereumi aadressiks.""" # Ethereumi aadressi genereerimine kasutab tihendamata avalikku võtit ilma 0x04 eesliiteta uncompressed_pk = public_key_bytes[1:] # 1. samm: Keccak-256 räsi keccak_hash = keccak_256(uncompressed_pk).digest() # 2. samm: võta viimased 20 baiti eth_address_bytes = keccak_hash[-20:] # 3. samm: vorminda '0x' eesliitega eth_address = '0x' + eth_address_bytes.hex() return eth_address ```5. samm: sõnumi allkirjastamine
Digitaalallkiri tõestab, et privaatvõtme omanik on sõnumi (näiteks tehingu) autoriseerinud. Protsess hõlmab sõnumi räsi allkirjastamist, mitte toorsõnumit ennast, tõhususe ja turvalisuse huvides.
```python def sign_message(private_key_bytes, message): """Allkirjasta sõnum antud privaatvõtmega.""" # Standardne praktika on allkirjastada sõnumi räsi message_hash = hashlib.sha256(message.encode('utf-8')).digest() sk = ecdsa.SigningKey.from_string(private_key_bytes, curve=ecdsa.SECP256k1) signature = sk.sign(message_hash) return signature ```6. samm: allkirja kontrollimine
Kontrollimine on vastupidine protsess. Igaüks, kellel on avalik võti, algne sõnum ja allkiri, saab kinnitada, et allkiri on autentne. Nii valideerib plokiahela võrk tehinguid.
```python def verify_signature(public_key_bytes, signature, message): """Kontrolli sõnumi allkirja antud avaliku võtmega.""" message_hash = hashlib.sha256(message.encode('utf-8')).digest() vk = ecdsa.VerifyingKey.from_string(public_key_bytes, curve=ecdsa.SECP256k1, hashfunc=hashlib.sha256) try: # Meetod verify tagastab True, kui see on kehtiv, või tekitab erandi return vk.verify(signature, message_hash) except ecdsa.BadSignatureError: return False ```Rahakoti kokkupanek: lihtne käsurealiides (CLI)
Nüüd, kui meil on kõik põhifunktsioonid olemas, paneme need kokku lihtsaks, kasutatavaks käsureatööriistaks. Me loome loogika kapseldamiseks klassi `Wallet` ja kasutame Pythoni `argparse` moodulit kasutaja käskude haldamiseks.
Siin on täielik skript, mis integreerib kõik meie funktsioonid sidusaks rakenduseks.
```python #!/usr/bin/env python3 import os import hashlib import base58 import ecdsa import argparse from sha3 import keccak_256 class Wallet: """Esindab krüptovaluuta rahakotti võtmehaldus ja aadressi genereerimisega.""" def __init__(self, private_key_hex=None): if private_key_hex: self.private_key = bytes.fromhex(private_key_hex) else: self.private_key = self._generate_private_key() self.public_key = self._private_to_public_key(self.private_key) self.btc_address = self._public_to_btc_address(self.public_key) self.eth_address = self._public_to_eth_address(self.public_key) def _generate_private_key(self): return os.urandom(32) def _private_to_public_key(self, private_key): sk = ecdsa.SigningKey.from_string(private_key, curve=ecdsa.SECP256k1) return sk.verifying_key.to_string("uncompressed") def _public_to_btc_address(self, public_key): sha256_hash = hashlib.sha256(public_key).digest() ripemd160 = hashlib.new('ripemd160') ripemd160.update(sha256_hash) hashed_pk = ripemd160.digest() versioned_hash = b'\x00' + hashed_pk checksum = hashlib.sha256(hashlib.sha256(versioned_hash).digest()).digest()[:4] binary_address = versioned_hash + checksum return base58.b58encode(binary_address).decode('utf-8') def _public_to_eth_address(self, public_key): uncompressed_pk = public_key[1:] keccak_hash = keccak_256(uncompressed_pk).digest() return '0x' + keccak_hash[-20:].hex() def display_details(self): print(f"Privaatne võti (hex): {self.private_key.hex()}") print(f"Avalik võti (hex): {self.public_key.hex()}") print(f"Bitcoini aadress: {self.btc_address}") print(f"Ethereumi aadress: {self.eth_address}") def main(): parser = argparse.ArgumentParser(description="Lihtne käsurea krüptovaluuta rahakott.") parser.add_argument("command", choices=["create", "details"], help="Käsk, mida täita.") parser.add_argument("--privatekey", help="Olemasolev privaatne võti hex vormingus, et saada üksikasju.") args = parser.parse_args() if args.command == "create": wallet = Wallet() print("--- Loodud uus rahakott ---") wallet.display_details() print("\n*** TÄHTIS ***") print("Salvestage oma privaatne võti turvalisse kohta. See on ainus viis oma rahale juurde pääseda.") elif args.command == "details": if not args.privatekey: print("Viga: Käsk 'details' nõuab privaatset võtit, kasutades lippu --privatekey.") return try: wallet = Wallet(private_key_hex=args.privatekey) print("--- Rahakoti üksikasjad ---") wallet.display_details() except Exception as e: print(f"Viga rahakoti laadimisel privaatvõtmest: {e}") if __name__ == "__main__": main() ```Kuidas seda CLI tööriista kasutada:
- Salvestage ĂĽlaltoodud kood Pythoni failina (nt `cli_wallet.py`).
- Avage oma terminal või käsuviip.
- Uue rahakoti loomiseks: `python cli_wallet.py create`
- Üksikasjade vaatamiseks olemasolevast privaatsest võtmest: `python cli_wallet.py details --privatekey YOUR_PRIVATE_KEY_IN_HEX`
Turvalisuse parimad tavad ja olulised kaalutlused
Oleme edukalt ehitanud põhifunktsionaalsusega rahakoti, kuid tootmiseks valmis rakendus nõuab palju suuremat keskendumist turvalisusele. Siin on mõned olulised punktid, mida kaaluda.
1. Ärge kunagi salvestage privaatseid võtmeid tavatekstina
Meie skript prindib privaatse võtme konsooli, mis on väga ebaturvaline. Tõelises rakenduses tuleks privaatseid võtmeid krüpteerida puhkeolekus, kasutades tugevat parooli. Neid tuleks dekrüpteerida ainult mälus, kui neid on vaja allkirjastamiseks. Professionaalsed lahendused kasutavad sageli riistvara turvamooduleid (HSM) või seadmete turvalisi enklaave võtmete kaitsmiseks.
2. Entroopia tähtsus
Teie rahakoti turvalisus algab juhuslikkusega (entroopiaga), mida kasutatakse privaatse võtme genereerimiseks. `os.urandom` on hea allikas enamikus kaasaegsetes operatsioonisüsteemides, kuid kõrge väärtusega rakenduste jaoks koguvad arendajad sageli entroopiat mitmest allikast, et tagada ettearvamatus.
3. Meeldejätvad fraasid (seemnefraasid) - tööstusstandard
Pikkade kuueteistkümnendsüsteemide privaatsete võtmete käsitsi varundamine on tülikas ja veaohtlik. Tööstus lahendas selle Hierarhiliste Deterministlike (HD) rahakottidega (määratletud BIP-32-s) ja Meeldejätvate fraasidega (BIP-39). Meeldejätv fraas on jada 12-24 tavalisest sõnast, mida saab kasutada teie peamise privaatse võtme ja kõigi järgnevate võtmete deterministlikuks regenereerimiseks. See muudab rahakoti varundamise ja taastamise palju kasutajasõbralikumaks.
4. See on hariduslik tööriist, mitte tootmisrahakott
On oluline korrata, et see rakendus on lihtsustatud mudel. Reaalmaailma rahakott peab haldama mitut aadressi, suhtlema plokiahela sõlmedega, et saada saldosid ja koostada tehinguid, arvutama tasusid ja edastama allkirjastatud tehinguid võrku. See vajab ka turvalist kasutajaliidest ja tugevat veakäsitlust.
5. Võrgu interaktsioon
Meie rahakott saab genereerida võtmeid ja allkirjastada sõnumeid, kuid see ei saa suhelda plokiahela võrguga. Täieliku rakenduse ehitamiseks peaksite integreerima teeke, mis saavad ühenduse luua plokiahela sõlmedega RPC (Remote Procedure Call) kaudu. Ethereumi jaoks on `web3.py` standardteek. Bitcoini jaoks saab kasutada teeke nagu `python-bitcoinlib`.
Järeldus ja järgmised sammud
Palju õnne! Olete Pythoni abil edukalt ehitanud krüptovaluuta rahakoti krüptograafilise tuuma. Oleme rännanud avaliku/privaatse võtme krüptograafia põhilistest teooriatest praktilise rakenduseni, mis genereerib kehtivaid aadresse nii Bitcoini kui ka Ethereumi võrkudele.
See projekt loob tugeva aluse plokiahela tehnoloogia sügavamaks uurimiseks. Olete omal nahal näinud, et rahakott on oma olemuselt keerukas võtmehaldussüsteem, mis on ehitatud tõestatud krüptograafiliste põhimõtetele.
Kuhu te siit edasi lähete? Kaaluge neid väljakutseid oma järgmiste sammudena:
- Rakenda HD rahakotid: Uurige standardeid BIP-32, BIP-39 ja BIP-44, et luua rahakott, mis suudab hallata miljoneid aadresseid ühe meeldejätva seemnefraasi abil.
- Ühenda võrguga: Kasutage `web3.py`, et ühendada Ethereumi sõlmega (nagu Infura või Alchemy), kontrollida aadressi saldot ja koostada toor-tehing.
- Ehita kasutajaliides: Loo lihtne graafiline kasutajaliides (GUI), kasutades raamistikku nagu Tkinter, või veebiliides, kasutades Flask/Django, et muuta oma rahakott kasutajasõbralikumaks.
- Uurige teisi plokiahelaid: Uurige, kuidas teised plokiahela platvormid oma aadresse genereerivad, ja kohandage oma koodi, et neid toetada.
Plokiahela maailm on ehitatud avatud lähtekoodiga koostööle ja teadmistejanule. Ehitades selliseid tööriistu, ei õpi te ainult kodeerima – te õpite uue digitaalse majanduse keelt. Jätkake katsetamist, jätkake ehitamist ja jätkake detsentraliseeritud tehnoloogia tohutu potentsiaali uurimist.